home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume1 / rot22 < prev    next >
Encoding:
Text File  |  1987-05-06  |  16.1 KB  |  670 lines

  1. Path: seismo!ut-sally!im4u!rutgers!mit-eddie!uw-beaver!tektronix!tekgen!tekred!games-request
  2. From: games-request@tekred.TEK.COM
  3. Newsgroups: comp.sources.games
  4. Subject: v01i008:  rot2.2 - software rot in action
  5. Message-ID: <1190@tekred.TEK.COM>
  6. Date: 5 May 87 23:51:44 GMT
  7. Sender: billr@tekred.TEK.COM
  8. Lines: 659
  9. Approved: billr@tekred.TEK.COM
  10.  
  11. Submitted by: Bill Randle <games-request@tekred.TEK.COM>
  12. Mod.sources.games: Volume 1, Issue 8
  13. Archive-name: rot22
  14.  
  15.     [This is the latest and last version of the rot program.  It
  16.      should be pretty well bullet-proof and even includes a man
  17.      page.  This completely supersedes the previous version of
  18.      rot (2.0, patchlevel 0) that was posted in v01i005.  Many
  19.      thanks to all the people that sent bug reports/fixes.  -br]
  20.  
  21. #! /bin/sh
  22. # This is a shell archive.  Remove anything before this line, then unpack
  23. # it by saving it into a file and typing "sh file".  To overwrite existing
  24. # files, type "sh file -c".  You can also feed this as standard input via
  25. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  26. # will see the following message at the end:
  27. #        "End of archive 1 (of 1)."
  28. # Contents:  README MANIFEST Makefile patchlvl.h rot.1 rot.c
  29. # Wrapped by billr@tekred on Tue May  5 16:41:11 1987
  30. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  31. if test -f README -a "${1}" != "-c" ; then 
  32.   echo shar: Will not over-write existing file \"README\"
  33. else
  34. echo shar: Extracting \"README\" \(270 characters\)
  35. sed "s/^X//" >README <<'END_OF_README'
  36. XThis program cascades letters from the top of the terminal screen
  37. Xto the bottom in a waterfall effect.  The original program has had
  38. Xseveral bugs fixed and added capability to properly handle padding.
  39. XAlso, this will be pretty slow at lower baudrates.
  40. X
  41. X                        4/22/87 BR
  42. END_OF_README
  43. if test 270 -ne `wc -c <README`; then
  44.     echo shar: \"README\" unpacked with wrong size!
  45. fi
  46. # end of overwriting check
  47. fi
  48. if test -f MANIFEST -a "${1}" != "-c" ; then 
  49.   echo shar: Will not over-write existing file \"MANIFEST\"
  50. else
  51. echo shar: Extracting \"MANIFEST\" \(294 characters\)
  52. sed "s/^X//" >MANIFEST <<'END_OF_MANIFEST'
  53. X   File Name        Archive #    Description
  54. X-----------------------------------------------------------
  55. X MANIFEST                  1    This shipping list
  56. X Makefile                  1    
  57. X README                    1    
  58. X patchlvl.h                1    
  59. X rot.1                     1    
  60. X rot.c                     1    
  61. END_OF_MANIFEST
  62. if test 294 -ne `wc -c <MANIFEST`; then
  63.     echo shar: \"MANIFEST\" unpacked with wrong size!
  64. fi
  65. # end of overwriting check
  66. fi
  67. if test -f Makefile -a "${1}" != "-c" ; then 
  68.   echo shar: Will not over-write existing file \"Makefile\"
  69. else
  70. echo shar: Extracting \"Makefile\" \(129 characters\)
  71. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  72. X# Simple makefile for rot program
  73. X
  74. XCFLAGS = -O #-DSYSV
  75. X
  76. Xrot:    rot.c
  77. X    cc $(CFLAGS) -o rot rot.c -ltermlib
  78. X
  79. Xtest:    rot
  80. X    ./rot <rot.c
  81. END_OF_Makefile
  82. if test 129 -ne `wc -c <Makefile`; then
  83.     echo shar: \"Makefile\" unpacked with wrong size!
  84. fi
  85. # end of overwriting check
  86. fi
  87. if test -f patchlvl.h -a "${1}" != "-c" ; then 
  88.   echo shar: Will not over-write existing file \"patchlvl.h\"
  89. else
  90. echo shar: Extracting \"patchlvl.h\" \(76 characters\)
  91. sed "s/^X//" >patchlvl.h <<'END_OF_patchlvl.h'
  92. X#define    PATCHLEVEL    2
  93. X
  94. X#define ROT_VERSION    "2.0 patchlevel 2, 22 April 1987"
  95. END_OF_patchlvl.h
  96. if test 76 -ne `wc -c <patchlvl.h`; then
  97.     echo shar: \"patchlvl.h\" unpacked with wrong size!
  98. fi
  99. # end of overwriting check
  100. fi
  101. if test -f rot.1 -a "${1}" != "-c" ; then 
  102.   echo shar: Will not over-write existing file \"rot.1\"
  103. else
  104. echo shar: Extracting \"rot.1\" \(986 characters\)
  105. sed "s/^X//" >rot.1 <<'END_OF_rot.1'
  106. X.TH ROT 6 
  107. X.SH NAME
  108. Xrot \- a visual demonstration of
  109. X.I software
  110. X.I rot.
  111. X.SH SYNOPSIS
  112. X.B rot
  113. X<file>
  114. X.PP
  115. XThis program cascades letters from the top of the terminal screen
  116. Xto the bottom in a waterfall effect.
  117. X.PP
  118. XThis program reads from standard input and can be used as
  119. Xan output
  120. Xfilter.
  121. XAn amusing use is:
  122. X.sp
  123. X    man rot | col -b | rot
  124. X.SH AUTHOR
  125. X.PP
  126. XOriginal source from Peter da Silva
  127. X.br
  128. X    (ihnp4!shell!neuro1!hyd-ptd!peter) or
  129. X.br
  130. X    (ihnp4!shell!neuro1!datafact!peter) or
  131. X.br
  132. X    (ihnp4!shell!neuro1!baylor!peter).
  133. X.sp
  134. XMakefile and README from Bill Randle (billr@tekred.TEK.COM).
  135. X.sp
  136. XMan page from John G Dobnick
  137. X.br
  138. X    (ihnp4!uwmcsd1!jgd) or
  139. X.br
  140. X    (jgd@csd1.milw.wisc.edu).
  141. X.sp
  142. XBug fixes from:
  143. X.br
  144. X    James Buster (bitbug@ucscb.ucsc.edu)
  145. X.br
  146. X     Ed Falk (ed@sun -?)
  147. X.br
  148. X     Andrew Klossner (andrew@lemming.gwd.tek.com)
  149. X.br
  150. X     Andrew Scott Beals (bandy@amdcad.amd.com)
  151. X.br
  152. X    Colin Plumb (ccplumb@watmath.uucp)
  153. X.br
  154. X     Bill Randle (billr@tekred.tek.com)
  155. X.SH BUGS
  156. XThis is pretty slow at lower baudrates.
  157. END_OF_rot.1
  158. if test 986 -ne `wc -c <rot.1`; then
  159.     echo shar: \"rot.1\" unpacked with wrong size!
  160. fi
  161. # end of overwriting check
  162. fi
  163. if test -f rot.c -a "${1}" != "-c" ; then 
  164.   echo shar: Will not over-write existing file \"rot.c\"
  165. else
  166. echo shar: Extracting \"rot.c\" \(10363 characters\)
  167. sed "s/^X//" >rot.c <<'END_OF_rot.c'
  168. X/*
  169. X * Revision History:
  170. X *
  171. X * Original source from:
  172. X *  Peter da Silva (ihnp4!shell!neuro1!{hyd-ptd,datafact,baylor}!peter)
  173. X *
  174. X * Changes for padding added by:
  175. X *  Andrew Scott Beals ({ucbvax,decwrl}!amdcad!bandy or bandy@amdcad.amd.com)
  176. X *  20 April 1987
  177. X *
  178. X * Additional changes for padding, fix for computation of tglen,
  179. X * increase max lines, improve termlib handling, add System V #ifdefs.
  180. X *  Bill Randle (billr@tekred.TEK.COM)
  181. X *  21 April 1987
  182. X *
  183. X * Add padding for cl.
  184. X *  Andrew Scott Beals ({ucbvax,decwrl}!amdcad!bandy or bandy@amdcad.amd.com)
  185. X *  22 April 1987
  186. X *
  187. X * Add comments and scroll fixes from Colin Plumb (ccplumb@watmath.UUCP)
  188. X * More terminal handling cleanup and error checking.
  189. X *  Bill Randle (billr@tekred.TEK.COM)
  190. X *  22 April 1987
  191. X */
  192. X
  193. X#include <stdio.h>
  194. X#include "patchlvl.h"
  195. X
  196. X#ifdef SYSV
  197. X# include <termio.h>
  198. X#else
  199. X# include <sgtty.h>
  200. X#endif
  201. X
  202. X/*        -- Miscellaneous defines --                     */
  203. X#define FALSE 0
  204. X#define TRUE 1
  205. X#define MAXCOL 80
  206. X#define MAXLI 36
  207. X
  208. X#define min(a,b)    ((a)<(b) ? a : b)
  209. X
  210. Xextern char *tgetstr();
  211. X
  212. Xint lastx, lasty;
  213. Xstruct _c {
  214. X    struct _c *c_next;
  215. X    int c_line, c_column;
  216. X    char c_mark;
  217. X} *clist;
  218. X
  219. X/*        -- Global variables --                         */
  220. Xchar *tent;                                               /* Pointer to tbuf */
  221. Xextern char PC;                                             /* Pad character */
  222. Xextern char *UP, *BC;                         /* Upline, backsapce character */
  223. Xextern short ospeed;                                /* Terminal output speed */
  224. Xint tglen, bclen;
  225. X
  226. Xchar *cm,                                                   /* Cursor motion */
  227. X     *cl,                                                    /* Clear screen */
  228. X     *ti,                            /* Init terminal */
  229. X     *te;                           /* Reset terminal */
  230. Xint  li,                                                  /* lines on screen */
  231. X     co;                                                    /* columns ditto */
  232. Xchar screen[MAXLI+1][MAXCOL];
  233. Xchar newscreen[MAXLI+1][MAXCOL];
  234. X
  235. Xmain(ac, av)
  236. Xint ac;
  237. Xchar **av;
  238. X{
  239. X    /* set ospeed so padding works correctly */
  240. X#ifdef SYSV
  241. X    struct termio    p;
  242. X
  243. X    if(ioctl(1, TCGETA, &p) != -1)
  244. X        ospeed=p.c_cflag & CBAUD;
  245. X#else
  246. X    struct sgttyb    p;
  247. X
  248. X    if(ioctl(1, TIOCGETP, &p) != -1)
  249. X        ospeed=p.sg_ospeed;
  250. X#endif
  251. X
  252. X    srand(getpid());    /* init random number generator */
  253. X    tinit(getenv("TERM"));    /* init terminal */
  254. X    if(ac > 1)
  255. X        /* do all files */
  256. X        while(--ac)
  257. X            dropf(*++av);
  258. X    else
  259. X        /* or stdin */
  260. X        fdropf(stdin);
  261. X    tend();            /* clean up terminal */
  262. X}
  263. X
  264. X/* put character c at (x, y) */
  265. Xat(x, y, c)
  266. Xint x, y;
  267. Xchar c;
  268. X{
  269. X#ifdef DEBUG
  270. X    _at(x, y);
  271. X#else
  272. X    /* optimize cursor motion if goal is on *same* line */
  273. X    if(y==lasty) {
  274. X        if(x!=lastx) {
  275. X            if(x<lastx && (lastx-x)*bclen<tglen)
  276. X                /* backspace into place if it takes */
  277. X                /* less characters than cursor motion */
  278. X                while(x<lastx) {
  279. X                    if (bclen > 1)
  280. X                        outs(BC);
  281. X                    else
  282. X                        putchar(*BC);
  283. X                    lastx--;
  284. X                }
  285. X            else if(x>lastx && x-lastx<tglen)
  286. X                /* print intervening characters */
  287. X                while(x>lastx) {
  288. X                    putchar(newscreen[lasty][lastx]);
  289. X                    lastx++;
  290. X                }
  291. X            else
  292. X                _at(x, y);
  293. X        }
  294. X    } else
  295. X        _at(x, y);
  296. X#endif
  297. X    c &= ~0200;
  298. X    putchar(c);
  299. X    if(c >= ' ' && c != '\177')
  300. X        lastx++;
  301. X    if(lastx>=co) {
  302. X        lastx -= co;
  303. X        lasty++;
  304. X    }
  305. X}
  306. X
  307. X_at(x, y)
  308. Xint x, y;
  309. X{
  310. X    extern void    outc();
  311. X
  312. X    tputs(tgoto(cm, x, y), 1, outc);     /* handle padding */
  313. X    lastx = x;
  314. X    lasty = y;
  315. X}
  316. X
  317. Xvoid
  318. Xoutc(c)
  319. Xregister c;
  320. X{
  321. X    putc(c, stdout);
  322. X}
  323. X
  324. X/* initialize terminal dependent variables */
  325. Xtinit(name)
  326. Xchar *name;
  327. X{
  328. X    static char junkbuf[1024], *junkptr;
  329. X    char tbuf[1024];
  330. X    int  intr();
  331. X
  332. X    junkptr = junkbuf;
  333. X
  334. X    tgetent(tbuf, name);
  335. X
  336. X    if (!tgetflag("bs"))        /* is backspace not used? */
  337. X        BC = tgetstr("bc",&junkptr);    /* find out what is */
  338. X    else
  339. X        BC = "\b";        /* make a backspace handy */
  340. X    bclen = strlen(BC);        /* for optimization stuff */
  341. X    if (tgetstr("pc", &junkptr) != NULL)
  342. X        PC = *junkptr;  /* set pad character */
  343. X    else
  344. X        PC = '\0';
  345. X    UP = tgetstr("up", &junkptr);
  346. X    cm = tgetstr("cm", &junkptr);
  347. X    if (cm == NULL) {
  348. X        printf("Can't rot on dumb terminals.\n");
  349. X        exit(1);
  350. X    }
  351. X    cl = tgetstr("cl", &junkptr);
  352. X    ti = tgetstr("ti", &junkptr);
  353. X    te = tgetstr("te", &junkptr);
  354. X    li = min(tgetnum("li"), MAXLI);
  355. X    if (li == -1)
  356. X        li = 24;
  357. X    /* the original code had special case code for last line and */
  358. X    /* last column.  Unfortunately, it didn't always work on all */
  359. X    /* terminals so we take the easy way out and don't use the   */
  360. X    /* bottom line of the screen                     */
  361. X    li--;    /* prevent bottom screen line from scrolling */
  362. X    co = min(tgetnum("co"), MAXCOL);
  363. X    if (co == -1)
  364. X        co = 80;
  365. X    tglen = strlen(tgoto(cm, co-1, li-1)); /* for optimization stuff */
  366. X    if (ti != NULL)
  367. X        outs(ti);
  368. X}
  369. X
  370. X/* cleanup terminal after use */
  371. Xtend()
  372. X{
  373. X    if (te != NULL)
  374. X        outs(te);
  375. X    _at(0, li);
  376. X    putchar('\n');
  377. X    fflush(stdout);
  378. X}
  379. X
  380. X/* read in a new screen */
  381. Xreadscreen(fp)
  382. XFILE *fp;
  383. X{
  384. X    int line, column, p;
  385. X    char tmp[256];
  386. X
  387. X    for(line=0; line<li; line++)
  388. X        for(column=0; column<co; column++)
  389. X            newscreen[line][column] = screen[line][column] = ' ';
  390. X    for(column=0; column<co; column++)
  391. X        newscreen[li][column] = screen[li][column] = '*';
  392. X    line=0;
  393. X    while(line<li) {
  394. X        if(!fgets(tmp, 256, fp))
  395. X            return;
  396. X
  397. X        for(column=0, p=0; tmp[p]; p++) {
  398. X            tmp[p] &= ~0200;
  399. X            if(tmp[p] < ' ' || tmp[p] == 127)
  400. X                switch(tmp[p]) {
  401. X                    case '\t':
  402. X                        while(++column % 8)
  403. X                            continue;
  404. X                        break;
  405. X                    case '\n':
  406. X                        column = 0;
  407. X                        line++;
  408. X                        break;
  409. X                    default:
  410. X                        newscreen[line][column] = '^';
  411. X                        column++;
  412. X                        if(column>=co) {
  413. X                            column -= co;
  414. X                            line++;
  415. X                        }
  416. X                        newscreen[line][column] =
  417. X                            (tmp[p]+'@') & 127;
  418. X                        column++;
  419. X                        break;
  420. X                }
  421. X            else {
  422. X                newscreen[line][column] = tmp[p];
  423. X                column++;
  424. X            }
  425. X            if(column >= co) {
  426. X                column -= co;
  427. X                line++;
  428. X            }
  429. X            if(line >= li)
  430. X                break;
  431. X        }
  432. X    }
  433. X    for(column=0; column<co; column++)
  434. X        newscreen[line][column] = screen[li][column] = '*';
  435. X}
  436. X
  437. Xdrawscreen()
  438. X{
  439. X    extern void    outc();
  440. X
  441. X    lastx = lasty = 0;
  442. X    if (cl != NULL)
  443. X        tputs(cl, li, outc);    /* for really slow terminals */
  444. X    update();
  445. X}
  446. X
  447. X/* copy newscreen[][] to physical screen and screen[][] */
  448. Xupdate()
  449. X{
  450. X    int l, c;
  451. X
  452. X    for(l=0; l<li; l++)
  453. X        for(c=0; c<co; c++)
  454. X            /* copy any changes */
  455. X            if(screen[l][c] != newscreen[l][c]) {
  456. X                /* are they *really* different? */
  457. X                if((screen[l][c] & ~0200) !=
  458. X                   (newscreen[l][c] & ~0200))
  459. X                    at(c, l, newscreen[l][c]);
  460. X                screen[l][c] = newscreen[l][c];
  461. X            }
  462. X}
  463. X
  464. X/* add char at (column, line) to clist if feasable */
  465. Xdrop(line, column)
  466. Xint line, column;
  467. X{
  468. X    struct _c *hold;
  469. X
  470. X    if(line<0 || line>=li || column<0 || column>=co || /* off screen */
  471. X       screen[line][column]==' ' || /* empty */
  472. X       screen[line][column] & 0200) /* already in list */
  473. X        return;
  474. X    if(screen[line+1][column]!=' ' &&
  475. X       (column==co-1 ||screen[line+1][column+1]!=' ') &&
  476. X       (column==0 ||screen[line+1][column-1]!=' ')) /* can't be dropped */
  477. X        return;
  478. X
  479. X    hold = (struct _c *) malloc(sizeof(struct _c));
  480. X    hold -> c_next = clist;
  481. X    hold -> c_column = column;
  482. X    hold -> c_line = line;
  483. X    hold -> c_mark = 0;
  484. X    screen[line][column] |= 0200;
  485. X    clist = hold;
  486. X}
  487. X
  488. X/* drop everything in the clist */
  489. Xdrops()
  490. X{
  491. X    int line, column;
  492. X    struct _c *hold;
  493. X
  494. X    for(hold = clist; hold; hold=hold->c_next) {
  495. X        line = hold->c_line;
  496. X        column = hold->c_column;
  497. X        /* add adjacent characters to clist */
  498. X        drop(line+1, column);
  499. X        drop(line, column+1);
  500. X        drop(line-1, column);
  501. X        drop(line, column-1);
  502. X        /* drop straight down if possible */
  503. X        if(newscreen[line+1][column]==' ') {
  504. X            newscreen[line+1][column] = screen[line][column];
  505. X            newscreen[line][column] = ' ';
  506. X            line++;
  507. X        }
  508. X        /* otherwise try and drop to the sides.  Randomly pick
  509. X        /* which side to try first. */
  510. X        else if(rand()&01000) {
  511. X            if(column>0 && newscreen[line][column-1] == ' ' &&
  512. X                newscreen[line+1][column-1]==' ') {
  513. X                newscreen[line][column-1] =
  514. X                    screen[line][column];
  515. X                newscreen[line][column] = ' ';
  516. X                column--;
  517. X            }
  518. X            else if(column<co-1 &&
  519. X                newscreen[line][column+1] == ' ' &&
  520. X                newscreen[line+1][column+1]==' ') {
  521. X                    newscreen[line][column+1] =
  522. X                        screen[line][column];
  523. X                    newscreen[line][column] = ' ';
  524. X                    column++;
  525. X            }
  526. X            else {
  527. X                /* forget it */
  528. X                screen[line][column] &= ~0200;
  529. X                newscreen[line][column] &= ~0200;
  530. X                hold -> c_mark = 1;
  531. X            }
  532. X        } else {
  533. X            if(column<co-1 && newscreen[line][column+1] == ' ' &&
  534. X                newscreen[line+1][column+1]==' ') {
  535. X                newscreen[line][column+1] =
  536. X                    screen[line][column];
  537. X                newscreen[line][column] = ' ';
  538. X                column++;
  539. X            }
  540. X            else if(column>0 && newscreen[line][column-1] == ' ' &&
  541. X                newscreen[line+1][column-1]==' ') {
  542. X                newscreen[line][column-1] =
  543. X                    screen[line][column];
  544. X                newscreen[line][column] = ' ';
  545. X                column--;
  546. X            }
  547. X            else {
  548. X                /* forget it */
  549. X                newscreen[line][column] &= ~0200;
  550. X                screen[line][column] &= ~0200;
  551. X                hold -> c_mark = 1;
  552. X            }
  553. X        }
  554. X        /* update list entry */
  555. X        hold -> c_column = column;
  556. X        hold -> c_line = line;
  557. X    }
  558. X
  559. X    /* delete all list entries marked for deletion */
  560. X    /* do all at head of list */
  561. X    while(clist && clist->c_mark) {
  562. X        struct _c *p = clist;
  563. X        clist = clist -> c_next;
  564. X        free(p);
  565. X    }
  566. X    /* ...and all in body */
  567. X    hold = clist;
  568. X    while(hold && hold->c_next)
  569. X        if(hold->c_next->c_mark) {
  570. X            struct _c *p = hold->c_next;
  571. X            hold->c_next = p->c_next;
  572. X            free(p);
  573. X        } else
  574. X            hold=hold->c_next;
  575. X}
  576. X
  577. Xdroplet(line, column)
  578. Xint line, column;
  579. X{
  580. X    int ret;
  581. X    while(column>=0 && screen[line][column]!=' ')
  582. X        column--;
  583. X    column++;
  584. X    while(column<co && screen[line][column]!=' ')
  585. X        drop(line, column++);
  586. X    ret = clist != 0;
  587. X    while(clist) {
  588. X        drops();
  589. X        update();
  590. X    }
  591. X    return ret;
  592. X}
  593. X
  594. Xdropscreen()
  595. X{
  596. X    int column, line;
  597. X    int rubbish = 0, count = 0;
  598. X
  599. X    do {
  600. X        int start, limit, incr;
  601. X        count++;
  602. X        rubbish = 0;
  603. X        if(count&1) { start=li-2; limit=0; incr = -1; }
  604. X        else { start=0; limit=li-2; incr=1; }
  605. X        for(line=start; line!=limit && !rubbish; line+=incr) {
  606. X            if(line&1)
  607. X                for(column=0; column<co && !rubbish; column++)
  608. X                    rubbish += droplet(line, column);
  609. X            else
  610. X                for(column=co-1; column>=0 && !rubbish; column--)
  611. X                    rubbish += droplet(line, column);
  612. X        }
  613. X    } while(rubbish);
  614. X}
  615. X
  616. Xdropf(file)
  617. Xchar *file;
  618. X{
  619. X    FILE *fp;
  620. X
  621. X    if((fp = fopen(file, "r")) == NULL) {
  622. X        perror(file);
  623. X        return;
  624. X    }
  625. X    fdropf(fp);
  626. X}
  627. X
  628. Xfdropf(fp)
  629. XFILE *fp;
  630. X{
  631. X    int i;
  632. X
  633. X    while(!feof(fp)) {
  634. X        readscreen(fp);
  635. X        drawscreen();
  636. X        for(i=0; i<20; i++)
  637. X            droplet((rand()>>4) % li, (rand()>>4) % co);
  638. X        dropscreen();
  639. X    }
  640. X}
  641. X
  642. Xouts(s)
  643. Xchar *s;
  644. X{
  645. X    fputs(s, stdout);
  646. X}
  647. END_OF_rot.c
  648. if test 10363 -ne `wc -c <rot.c`; then
  649.     echo shar: \"rot.c\" unpacked with wrong size!
  650. fi
  651. # end of overwriting check
  652. fi
  653. echo shar: End of archive 1 \(of 1\).
  654. cp /dev/null ark1isdone
  655. MISSING=""
  656. for I in 1 ; do
  657.     if test ! -f ark${I}isdone ; then
  658.     MISSING="${MISSING} ${I}"
  659.     fi
  660. done
  661. if test "${MISSING}" = "" ; then
  662.     echo You have unpacked all 1 archives.
  663.     rm -f ark[1-9]isdone
  664. else
  665.     echo You still need to unpack the following archives:
  666.     echo "        " ${MISSING}
  667. fi
  668. ##  End of shell archive.
  669. exit 0
  670.